package test_pkg

import (
	"container/list"
	"container/ring"
	"fmt"
)

// 双向链表
func Test_list() {
	l := list.New()

	e1 := l.PushFront(1)
	e4 := l.PushBack(4)
	l.InsertBefore(3, e4)
	l.InsertAfter(2, e1)

	//循环
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}

	fmt.Printf("l.Front(): 第一位 %v\n", l.Front().Value)
	fmt.Printf("l.Back(): 最后一位 %v\n", l.Back().Value)

	//移动位置
	l.MoveAfter(e1, e4)
	l.MoveBefore(e1, e4)
	l.MoveToFront(e4)
	l.MoveToBack(e1)
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}
	fmt.Printf("l.Len() %v\n", l.Len())

	fmt.Println("--- remove e1 ----")
	//删除元素
	l.Remove(e1)
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}

	fmt.Printf("l.Len() %v\n", l.Len())

}

// ring 圈
func Test_ring() {
	r := ring.New(4)
	len := r.Len()

	//赋值
	for i := 0; i < len; i++ {
		r.Value = i
		r = r.Next()
	}

	// r.Do(func(p any) {
	// 	fmt.Println(p.(int))
	// })

	s := ring.New(2)
	for i := 0; i < 2; i++ {
		s.Value = i + 7
		s = s.Next()
	}
	// fmt.Println("--- s --- ")
	// s.Do(func(p any) {
	// 	fmt.Println(p.(int))
	// })

	fmt.Println("----- r")
	r.Do(func(p any) {
		fmt.Println(p.(int))
	})

	fmt.Println("-----  s")
	s.Do(func(p any) {
		fmt.Println(p.(int))
	})

	fmt.Println("----- link s r")
	//使得r.Next()变为s并返回r.Next()的原始值。R不能为空。
	// 如果r和s指向同一个环，则链接它们会从环中删除r和s之间的元素。删除的元素形成一个子环，结果是对该子环的引用(如果没有删除任何元素，则结果仍然是r.Next()的原始值，而不是nil)。
	// 如果r和s指向不同的环，则将它们链接起来将创建一个环，其中s的元素插入r之后。结果指向插入后s的最后一个元素后面的元素
	//如本例中 r.next 原本是 1 连接后 r.next 变为 s 7 8, (所以链接后 是  0 7 8 1 2 3 ) 同时结果指向 s 的最后一个元素  所以 r1.next 是 1

	r1 := r.Link(s)
	r1.Do(func(p any) {
		fmt.Println(p.(int))
	})

	fmt.Println("----链接同一个环 ----")
	//链接同一个环
	r2 := ring.New(3)
	// Get the length of the ring
	n := r2.Len()
	// Initialize the ring with some integer values
	for i := 0; i < n; i++ {
		r2.Value = i
		r2 = r2.Next()
	}
	rs := r2.Link(r2)

	// Iterate through the combined ring and print its contents
	rs.Do(func(p any) {
		fmt.Println(p.(int))
	})
}
